/*
* Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
* Header LEXICAL.CPP
*
*/


#include "LEXICAL.H"

Lexical::Lexical()
 :	iType(ELexNL), iNumber(0)
	{
	iText[0] = '\0';
	}

Lexical::Lexical(const Lexical& aLex)
	{
	iType = aLex.iType;
	iNumber = aLex.iNumber;
	strcpy(iText, aLex.iText);
	}

Lexical& Lexical::operator = (const Lexical& aLex)
	{
	iType = aLex.iType;
	iNumber = aLex.iNumber;
	strcpy(iText, aLex.iText);
	return *this;
	}

int Lexical::CovertStringToHex()
	{
	char* curPtr = iText; // Position of current lexical in line
	int hexDigit;
	int number = 0;

	while (HexDigit(*curPtr, hexDigit))
		{
		number = (16 * number) + hexDigit;
		curPtr++;
		}
	return number;
	}

int Lexical::HexDigit(char aDigit, int& decimalEquivalent)
	{
	boolean validDigit = efalse;
	if ((aDigit >= '0') && (aDigit <= '9'))
		{
		decimalEquivalent = (aDigit - '0');
		validDigit = etrue;
		}
	else if ((aDigit >= 'a') && (aDigit <= 'f'))
		{
		decimalEquivalent = 10 + (aDigit - 'a');
		validDigit = etrue;
		}
	else if ((aDigit >= 'A') && (aDigit <= 'F'))
		{
		decimalEquivalent = 10 + (aDigit - 'A');
		validDigit = etrue;
		}
	return validDigit;
	}

ostream& operator << (ostream& out, const Lexical& aLex)
	{
	switch (aLex.iType)
		{
		case ELexEOF:
			{
			out << "EOF";
			break;
			}
		case ELexNL:
			{
			out << "NL";
			break;
			}
		case ELexNumber:
			{
			out << aLex.iNumber;
			break;
			}
		case ELexOperator:
			{
			out << aLex.iText[0];
			break;
			}
		default:
			{
			out << aLex.iText;
			}
		}	 
	return out;
	}

LexAnal::LexAnal(const char* aFilename)
 :	iFilename(aFilename)
	{
	iFin.open(aFilename);
	iLex.iType = ELexNL;
	iLineNo = 0;
	}

Lexical LexAnal::Read() // read next lexical into iLex
	{
	if (iLex.iType == ELexNL)
		{
		do
			{
			GetNextLex();
			}
		while (iLex.iType == ELexNL);
		}
	else
		GetNextLex();
	return iLex;
	}

Lexical LexAnal::ReadNextLine() // read first lex on next line
	{
	GetNextLine();
	return iLex;
	}

void LexAnal::Report()
	{
	cerr << iFilename.Text() << '(' << iLineNo << "): \n";
	cerr << iLine << '\n';
	for	(char* p = iLine; p < iLexPtr; p++)
		cerr << ' ';
	cerr << "^\n";
	}

LexAnal::~LexAnal()
	{
	iFin.close();
	}

void LexAnal::GetNextLex()
	{
	char ch;
	if (iLex.iType == ELexNL)
		{
		iFin.getline(iLine, MaxLineLen);
		// Remove any CR character that appear at the end when
		// reading a dos file on unix.
		PurgeLastCR(iLine);
		iCurPtr = iLine;
		iLineNo++;
		}

	while ((*iCurPtr == ' ') || (*iCurPtr == '\t'))
		iCurPtr++;
	ch = *iCurPtr;
	iLexPtr = iCurPtr;

	if ((ch == '\0') && (iFin.eof()))	// finds lexical type
		iLex = ReadEOF();
	else if ((ch == '\0') || (ch == '!'))	// ! is a comment
		iLex = ReadNewLine();
	else if ((ch == '-') || ((ch >= '0') && (ch <= '9')))
		iLex = ReadNumber();
	else if (((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z')) || (ch == '_'))
		iLex = ReadIdent();
	else if	(ch == '"')
		iLex = ReadString();
	else
		iLex = ReadOperator();	
	}

void LexAnal::GetNextLine()
	{
	iFin.getline(iLine, MaxLineLen);
	// Remove any CR character that appear at the end when
	// reading a dos file on unix.
	PurgeLastCR(iLine);
	iCurPtr = iLine;
	iLineNo++;

	char ch;
	while ((*iCurPtr == ' ') || (*iCurPtr == '\t'))
		iCurPtr++;
	ch = *iCurPtr;
	iLexPtr = iCurPtr;

	if ((ch == '\0') && (iFin.eof()))	// finds lexical type
		iLex = ReadEOF();
	else if ((ch == '\0') || (ch == '!'))
		iLex = ReadNewLine();
	else if ((ch == '-') || ((ch >= '0') && (ch <= '9')))
		iLex=ReadNumber();
	else if (((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z')) || (ch == '_'))
		iLex = ReadIdent();
	else if	(ch == '"')
		iLex = ReadString();
	else
		iLex = ReadOperator();	
	}

void LexAnal::PurgeLastCR(char *aLine)
	{
	int len = strlen(aLine) - 1;
	if (len >= 0 && aLine[len] == '\r')
		{
		aLine[len] = '\0';
		}
	}

Lexical LexAnal::ReadEOF()
	{
	Lexical lex;
	lex.iType = ELexEOF;
	return lex;
	}

Lexical LexAnal::ReadNewLine()
	{
	Lexical lex;
	lex.iType = ELexNL;
	while (*iCurPtr != '\0')
		iCurPtr++;
	return lex;
	}

Lexical LexAnal::ReadNumber()
	{
	Lexical lex;
	char ch;
	boolean negative = efalse;
	lex.iType = ELexNumber;
	if (*iCurPtr == '-')
		{
		negative = etrue;
		iCurPtr++;
		}
	ch = *iCurPtr;
	while ((ch >= '0') && (ch <= '9'))
		{
		if (negative)
			lex.iNumber = (10 * lex.iNumber) - (*iCurPtr - '0');
		else
			lex.iNumber=(10 * lex.iNumber) + (*iCurPtr - '0');
		iCurPtr++;
		ch = *iCurPtr;
		}
	return lex;
	}


Lexical LexAnal::ReadIdent()
	{
	Lexical lex;
	char ch;
	lex.iType = ELexIdent;
	do
		{
		iCurPtr++;
		ch = *iCurPtr;
		}
	while (((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z')) || (ch == '_') || ((ch >= '0') && (ch <= '9')));
	strncpy(lex.iText, iLexPtr, iCurPtr - iLexPtr);
	lex.iText[iCurPtr - iLexPtr] = '\0';
	return lex;
	}

Lexical LexAnal::ReadString()
	{
	Lexical lex;
	char ch;
	lex.iType = ELexString;
	iCurPtr++;
	ch = *iCurPtr;
	while ((ch != '"') && (*iCurPtr != '\0'))
		{
		iCurPtr++;
		ch = *iCurPtr;
		}
	strncpy(lex.iText, iLexPtr + 1, iCurPtr - (iLexPtr + 1));
	lex.iText[iCurPtr - (iLexPtr + 1)] = '\0';
	if (ch == '"')
		iCurPtr++;	// finds position after last double quotes 
	else
		{
		cerr << "Warning: missing quotes\n";
		Report();
		}
	return lex;
	}

Lexical LexAnal::ReadOperator()
	{
	Lexical lex;
	lex.iType = ELexOperator;
	lex.iText[0] = *iCurPtr;
	iCurPtr++;
	return lex;
	}
